import { Op } from 'sequelize';
import Post from '@/models/system/post.model';
import UserPost from '@/models/system/userPost.model';
import { getLogger } from '@/utils/logger';

const logger = getLogger("post-service", {
  console: false,
});
const consoleLogger = getLogger("post-service");

class PostService {
  /**
   * 格式化岗位数据，确保flag字段存在
   * @param post 岗位数据对象或JSON
   * @returns 格式化后的岗位数据
   */
  private formatPostData(post: any): any {
    try {
      logger.debug(`格式化岗位数据: postId=${post.postId || 'unknown'}`);
      
      const postData = post.toJSON ? post.toJSON() : { ...post };
      if (postData.flag === undefined) {
        postData.flag = false;
      }
      return postData;
    } catch (error) {
      consoleLogger.error(`格式化岗位数据失败: ${error instanceof Error ? error.message : String(error)}`);
      // 返回原始数据，避免抛出异常影响主流程
      return post;
    }
  }

  /**
   * 查询岗位信息集合
   * @param params 查询参数
   * @param pageNum 页码
   * @param pageSize 每页条数
   */
  async selectPostList(params: any, pageNum?: number, pageSize?: number) {
    try {
      // 使用consoleLogger记录操作开始
      consoleLogger.info(`查询岗位列表: ${JSON.stringify(params)}, pageNum=${pageNum}, pageSize=${pageSize}`);
      
      const { postCode, postName, status } = params;
      
      const where: any = {};
      
      if (postCode) {
        where.postCode = { [Op.like]: `%${postCode}%` };
      }
      
      if (postName) {
        where.postName = { [Op.like]: `%${postName}%` };
      }
      
      if (status) {
        where.status = status;
      }
      
      const queryOptions: any = {
        where,
        order: [['postSort', 'ASC']]
      };
      
      // 分页
      if (pageNum !== undefined && pageSize !== undefined) {
        queryOptions.offset = (pageNum - 1) * pageSize;
        queryOptions.limit = pageSize;
        
        const { count, rows } = await Post.findAndCountAll(queryOptions);
        
        // 使用格式化函数处理每个岗位数据
        const formattedRows = rows.map(post => this.formatPostData(post));
        
        // 记录查询结果
        logger.info(`岗位列表查询完成(分页): 总数=${count}, 当前页=${pageNum}, 每页条数=${pageSize}, 返回数据=${formattedRows.length}`);
        
        return {
          total: count,
          rows: formattedRows
        };
      } else {
        const posts = await Post.findAll(queryOptions);
        
        // 使用格式化函数处理每个岗位数据
        const formattedPosts = posts.map(post => this.formatPostData(post));
        
        // 记录查询结果
        logger.info(`岗位列表查询完成: 总数=${formattedPosts.length}`);
        
        return formattedPosts;
      }
    } catch (error) {
      consoleLogger.error(`查询岗位列表失败: ${error instanceof Error ? error.message : String(error)}`);
      // 分页查询时返回空对象，非分页查询时返回空数组
      return pageNum !== undefined ? { total: 0, rows: [] } : [];
    }
  }
  
  /**
   * 查询所有岗位
   */
  async selectPostAll() {
    try {
      // 使用consoleLogger记录操作开始
      consoleLogger.info("查询所有岗位");
      
      const posts = await Post.findAll({
        order: [['postSort', 'ASC']]
      });
      
      // 使用格式化函数处理每个岗位数据
      const formattedPosts = posts.map(post => this.formatPostData(post));
      
      // 记录查询结果
      logger.info(`所有岗位查询完成: 总数=${formattedPosts.length}`);
      
      return formattedPosts;
    } catch (error) {
      consoleLogger.error(`查询所有岗位失败: ${error instanceof Error ? error.message : String(error)}`);
      return [];
    }
  }
  
  /**
   * 通过岗位ID查询岗位信息
   * @param postId 岗位ID
   */
  async selectPostById(postId: number) {
    try {
      // 使用consoleLogger记录操作开始
      consoleLogger.info(`根据ID查询岗位: postId=${postId}`);
      
      const post = await Post.findByPk(postId);
      if (post) {
        // 使用格式化函数处理岗位数据
        const formattedPost = this.formatPostData(post);
        
        // 记录查询结果
        logger.info(`岗位查询成功: postId=${postId}, postName=${formattedPost.postName}`);
        
        return formattedPost;
      }
      
      logger.info(`未找到岗位: postId=${postId}`);
      return null;
    } catch (error) {
      consoleLogger.error(`根据ID查询岗位失败: ${error instanceof Error ? error.message : String(error)}`);
      return null;
    }
  }
  
  /**
   * 根据用户ID获取岗位选择框列表
   * @param userId 用户ID
   */
  async selectPostListByUserId(userId: number) {
    try {
      // 使用consoleLogger记录操作开始
      consoleLogger.info(`根据用户ID获取岗位选择框列表: userId=${userId}`);
      
      // 查询所有岗位
      const posts = await this.selectPostAll();
      
      // 查询用户所属岗位
      const userPosts = await UserPost.findAll({
        where: { userId }
      });
      
      const userPostIds = userPosts.map(up => up.postId);
      
      // 标记用户所属岗位
      const markedPosts = posts.map(post => {
        post.flag = userPostIds.includes(post.postId);
        return post;
      });
      
      // 记录查询结果
      logger.info(`用户岗位选择框列表查询完成: userId=${userId}, 总岗位数=${posts.length}, 用户已选岗位数=${userPostIds.length}`);
      
      return markedPosts;
    } catch (error) {
      consoleLogger.error(`根据用户ID获取岗位选择框列表失败: ${error instanceof Error ? error.message : String(error)}`);
      return [];
    }
  }
  
  /**
   * 校验岗位名称是否唯一
   * @param post 岗位信息
   */
  async checkPostNameUnique(post: any) {
    try {
      // 使用consoleLogger记录操作开始
      consoleLogger.info(`校验岗位名称唯一性: postName=${post.postName}, postId=${post.postId || '未提供'}`);
      
      const { postName, postId } = post;
      
      const where: any = { postName };
      
      if (postId) {
        where.postId = { [Op.ne]: postId };
      }
      
      const existingPost = await Post.findOne({ where });
      const isUnique = !existingPost;
      
      // 记录校验结果
      logger.info(`岗位名称唯一性校验完成: postName=${postName}, 是否唯一=${isUnique}`);
      
      return isUnique;
    } catch (error) {
      consoleLogger.error(`校验岗位名称唯一性失败: ${error instanceof Error ? error.message : String(error)}`);
      // 出错时返回false，表示不唯一，避免误添加
      return false;
    }
  }
  
  /**
   * 校验岗位编码是否唯一
   * @param post 岗位信息
   */
  async checkPostCodeUnique(post: any) {
    try {
      // 使用consoleLogger记录操作开始
      consoleLogger.info(`校验岗位编码唯一性: postCode=${post.postCode}, postId=${post.postId || '未提供'}`);
      
      const { postCode, postId } = post;
      
      const where: any = { postCode };
      
      if (postId) {
        where.postId = { [Op.ne]: postId };
      }
      
      const existingPost = await Post.findOne({ where });
      const isUnique = !existingPost;
      
      // 记录校验结果
      logger.info(`岗位编码唯一性校验完成: postCode=${postCode}, 是否唯一=${isUnique}`);
      
      return isUnique;
    } catch (error) {
      consoleLogger.error(`校验岗位编码唯一性失败: ${error instanceof Error ? error.message : String(error)}`);
      // 出错时返回false，表示不唯一，避免误添加
      return false;
    }
  }
  
  /**
   * 通过岗位ID查询岗位使用数量
   * @param postId 岗位ID
   */
  async countUserPostById(postId: number) {
    try {
      // 使用consoleLogger记录操作开始
      consoleLogger.info(`查询岗位使用数量: postId=${postId}`);
      
      const count = await UserPost.count({
        where: { postId }
      });
      
      // 记录查询结果
      logger.info(`岗位使用数量查询完成: postId=${postId}, 使用数量=${count}`);
      
      return count;
    } catch (error) {
      consoleLogger.error(`查询岗位使用数量失败: ${error instanceof Error ? error.message : String(error)}`);
      // 出错时返回-1，表示查询失败
      return -1;
    }
  }
  
  /**
   * 删除岗位信息
   * @param postId 岗位ID
   */
  async deletePostById(postId: number) {
    try {
      // 使用consoleLogger记录操作开始
      consoleLogger.info(`删除岗位: postId=${postId}`);
      
      const result = await Post.destroy({
        where: { postId }
      });
      
      // 记录操作结果
      logger.info(`岗位删除完成: postId=${postId}, 影响行数=${result}`);
      
      return result;
    } catch (error) {
      consoleLogger.error(`删除岗位失败: ${error instanceof Error ? error.message : String(error)}`);
      throw new Error('删除岗位失败');
    }
  }
  
  /**
   * 批量删除岗位信息
   * @param postIds 需要删除的岗位ID
   */
  async deletePostByIds(postIds: number[]) {
    try {
      // 使用consoleLogger记录操作开始
      consoleLogger.info(`批量删除岗位: postIds=${JSON.stringify(postIds)}`);
      
      const result = await Post.destroy({
        where: {
          postId: {
            [Op.in]: postIds
          }
        }
      });
      
      // 记录操作结果
      logger.info(`批量岗位删除完成: 删除数量=${result}, 请求删除数量=${postIds.length}`);
      
      return result;
    } catch (error) {
      consoleLogger.error(`批量删除岗位失败: ${error instanceof Error ? error.message : String(error)}`);
      throw new Error('批量删除岗位失败');
    }
  }
  
  /**
   * 新增保存岗位信息
   * @param post 岗位信息
   */
  async insertPost(post: any) {
    try {
      // 使用consoleLogger记录操作开始
      consoleLogger.info(`新增岗位: postName=${post.postName}, postCode=${post.postCode}`);
      
      const newPost = await Post.create(post);
      
      // 使用格式化函数处理岗位数据
      const formattedPost = this.formatPostData(newPost);
      
      // 记录操作结果
      logger.info(`岗位新增成功: postId=${formattedPost.postId}, postName=${formattedPost.postName}`);
      
      return formattedPost;
    } catch (error) {
      consoleLogger.error(`新增岗位失败: ${error instanceof Error ? error.message : String(error)}`);
      throw new Error('新增岗位失败');
    }
  }
  
  /**
   * 修改保存岗位信息
   * @param post 岗位信息
   */
  async updatePost(post: any) {
    try {
      // 使用consoleLogger记录操作开始
      consoleLogger.info(`修改岗位: postId=${post.postId}, postName=${post.postName}`);
      
      await Post.update(post, {
        where: { postId: post.postId }
      });
      
      // 返回更新后的完整数据
      const updatedPost = await this.selectPostById(post.postId);
      
      // 记录操作结果
      logger.info(`岗位修改成功: postId=${post.postId}, postName=${post.postName}`);
      
      return updatedPost;
    } catch (error) {
      consoleLogger.error(`修改岗位失败: ${error instanceof Error ? error.message : String(error)}`);
      throw new Error('修改岗位失败');
    }
  }
  
  /**
   * 获取用户岗位
   * @param userName 用户名
   */
  async getPostsByUserName(userName: string) {
    try {
      // 使用consoleLogger记录操作开始
      consoleLogger.info(`获取用户岗位: userName=${userName}`);
      
      const posts = await Post.findAll({
        include: [
          {
            association: Post.associations.Users,
            where: { userName, delFlag: '0' },
            required: true,
            attributes: []
          }
        ]
      });
      
      // 使用格式化函数处理每个岗位数据
      const formattedPosts = posts.map(post => this.formatPostData(post));
      
      // 记录查询结果
      logger.info(`用户岗位查询完成: userName=${userName}, 岗位数量=${formattedPosts.length}`);
      
      return formattedPosts;
    } catch (error) {
      consoleLogger.error(`获取用户岗位失败: ${error instanceof Error ? error.message : String(error)}`);
      return [];
    }
  }
}

export default new PostService(); 